Express 基础

┌─────────────────────────────────────────────────────────────┐
│                         Express 应用                         │
├─────────────────────────────────────────────────────────────┤
│  ┌─────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │ 路由层  │  │  中间件层   │  │      业务处理层         │  │
│  ├─────────┤  ├─────────────┤  ├─────────────────────────┤  │
│  │ Router  │→ │ Middleware  │→ │ Route Handlers          │  │
│  │ 路由匹配 │  │ 请求预处理  │  │ 业务逻辑 & 响应生成      │  │
│  └─────────┘  └─────────────┘  └─────────────────────────┘  │
├─────────────────────────────────────────────────────────────┤
│                      Node.js HTTP 模块                       │
└─────────────────────────────────────────────────────────────┘

客户端请求
    │
    ▼
┌──────────────────┐
│  Node.js HTTP    │  接收 HTTP 请求
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  Express App     │  创建 req/res 对象
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  中间件链        │  依次执行：日志 → 解析 → 认证 → ...
│  (Middleware)    │
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  路由匹配        │  匹配对应的路由处理函数
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  业务逻辑        │  执行具体业务，生成响应
└────────┬─────────┘
         │
         ▼
┌──────────────────┐
│  发送响应        │  返回 HTTP 响应给客户端
└──────────────────┘

# 检查 Node.js 版本
node -v

# 检查 npm 版本
npm -v

# 创建项目目录
mkdir my-express-app
cd my-express-app

# 初始化项目（生成 package.json）
npm init -y

# 安装 Express
npm install express@4

// 1. 引入 express 模块
const express = require("express")

// 2. 创建 express 应用实例
const app = express()

// 3. 定义路由
app.get("/", (req, res) => {
  res.send("Hello, Express!")
})

// 4. 启动服务器
const PORT = 3000
app.listen(PORT, () => {
  console.log(`服务器已启动: http://localhost:${PORT}`)
})

node app.js

my-express-app/
├── app.js              # 应用入口
├── package.json        # 项目配置
├── config/             # 配置文件
│   └── index.js
├── routes/             # 路由模块
│   ├── index.js        # 路由入口
│   ├── users.js        # 用户路由
│   └── products.js     # 产品路由
├── controllers/        # 控制器（业务逻辑）
│   └── userController.js
├── middleware/         # 自定义中间件
│   ├── auth.js         # 认证中间件
│   └── errorHandler.js # 错误处理
├── models/             # 数据模型
│   └── User.js
├── public/             # 静态资源
│   ├── css/
│   ├── js/
│   └── images/
└── views/              # 模板文件（如使用模板引擎）
    └── index.html

// 设置运行环境
app.set("env", "development") // development | production | test

// 设置模板引擎
app.set("view engine", "ejs")

// 设置模板目录
app.set("views", "./views")

// 设置严格路由匹配
app.set("strict routing", true)

// 获取配置
console.log(app.get("env"))

const express = require("express")
const app = express()

// 解析 JSON 请求体
app.use(express.json())

// 解析 URL 编码的请求体
app.use(express.urlencoded({ extended: true }))

// 获取路由参数和查询字符串
app.get("/users/:id", (req, res) => {
  const { id } = req.params           // 路由参数
  const { fields } = req.query        // 查询字符串
  const userAgent = req.header("user-agent")

  res.json({
    userId: id,
    fields,
    userAgent,
    timestamp: new Date().toISOString()
  })
})

// 处理 POST 请求
app.post("/users", (req, res) => {
  const { name, email } = req.body    // 请求体

  if (!name || !email) {
    return res.status(400).json({
      error: "name 和 email 为必填字段"
    })
  }

  res.status(201).json({
    message: "用户创建成功",
    user: { name, email }
  })
})

// 重定向
app.get("/old-page", (req, res) => {
  res.redirect(301, "/new-page")      // 永久重定向
})

app.get("/new-page", (req, res) => {
  res.send("这是新页面")
})

// 下载文件
app.get("/download", (req, res) => {
  res.download("./files/report.pdf")
})

app.listen(3000)

# GET 请求
curl http://localhost:3000/users/123?fields=name,email

# POST 请求
curl -X POST http://localhost:3000/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","email":"alice@example.com"}'

# 重定向测试
curl -I http://localhost:3000/old-page

// 基本语法
app.METHOD(PATH, HANDLER)

// 示例
app.get("/", (req, res) => res.send("GET 请求"))
app.post("/users", (req, res) => res.send("POST 请求"))
app.put("/users/:id", (req, res) => res.send("PUT 请求"))
app.delete("/users/:id", (req, res) => res.send("DELETE 请求"))

// 匹配所有 HTTP 方法
app.all("/secret", (req, res) => {
  res.send(`收到 ${req.method} 请求`)
})

// 必需参数
app.get("/users/:id", (req, res) => {
  res.json({ userId: req.params.id })
})

// 多个参数
app.get("/users/:userId/books/:bookId", (req, res) => {
  res.json(req.params)  // { userId: "123", bookId: "456" }
})

// 参数正则约束
app.get("/users/:id(\\d+)", (req, res) => {
  res.send(`数字 ID: ${req.params.id}`)  // 只匹配数字
})

// 可选参数
app.get("/books/:year?/:month?", (req, res) => {
  res.json(req.params)  // year 和 month 都是可选的
})

请求 → 中间件1 → 中间件2 → 中间件3 → 路由处理 → 响应
         │          │          │
         ▼          ▼          ▼
       next()     next()     next()

const express = require("express")
const app = express()

// 解析 JSON 请求体
app.use(express.json())

// 解析 URL 编码请求体
app.use(express.urlencoded({ extended: true }))

// 托管静态文件
app.use(express.static("public"))
// 访问 http://localhost:3000/images/logo.png

// 日志中间件
app.use((req, res, next) => {
  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`)
  next()
})

// 认证中间件（针对特定路径）
app.use("/admin", (req, res, next) => {
  const token = req.header("Authorization")
  if (!token) {
    return res.status(401).json({ error: "未授权" })
  }
  next()
})

npm install ejs

const express = require("express")
const app = express()

// 设置模板引擎
app.set("view engine", "ejs")
app.set("views", "./views")

// 渲染模板
app.get("/", (req, res) => {
  res.render("index", {
    title: "Express App",
    users: [
      { name: "Alice", age: 25 },
      { name: "Bob", age: 30 }
    ]
  })
})

<!DOCTYPE html>
<html>
<head>
  <title><%= title %></title>
</head>
<body>
  <h1><%= title %></h1>
  <ul>
    <% users.forEach(user => { %>
      <li><%= user.name %> - <%= user.age %>岁</li>
    <% }) %>
  </ul>
</body>
</html>

// 托管 public 目录
app.use(express.static("public"))

// 指定虚拟路径前缀
app.use("/static", express.static("public"))

// 使用绝对路径
const path = require("path")
app.use("/static", express.static(path.join(__dirname, "public")))

app.use(express.static("public", {
  maxAge: "1d",           // 缓存时间
  etag: true,             // 启用 ETag
  lastModified: true,     // 启用 Last-Modified
  setHeaders: (res, path) => {
    if (path.endsWith(".html")) {
      res.setHeader("Cache-Control", "no-cache")
    }
  }
}))

// 同步错误 - Express 自动捕获
app.get("/sync-error", (req, res) => {
  throw new Error("同步错误")
})

// 异步错误 - 需要 next(err) 传递
app.get("/async-error", async (req, res, next) => {
  try {
    const data = await someAsyncOperation()
    res.json(data)
  } catch (error) {
    next(error)
  }
})

// 404 处理（在所有路由之后）
app.use((req, res, next) => {
  res.status(404).json({ error: "资源未找到" })
})

// 全局错误处理（必须在最后）
app.use((err, req, res, next) => {
  console.error(err.stack)
  
  res.status(err.status || 500).json({
    error: {
      message: err.message || "服务器内部错误",
      ...(process.env.NODE_ENV === "development" && { stack: err.stack })
    }
  })
})

npm install dotenv

NODE_ENV=development
PORT=3000
DB_HOST=localhost
DB_PORT=27017
DB_NAME=myapp
JWT_SECRET=your-secret-key

require("dotenv").config()

const express = require("express")
const app = express()

const PORT = process.env.PORT || 3000
const NODE_ENV = process.env.NODE_ENV || "development"

app.listen(PORT, () => {
  console.log(`服务器运行在 ${NODE_ENV} 模式，端口 ${PORT}`)
})

const config = {
  development: {
    port: 3000,
    db: {
      host: "localhost",
      port: 27017,
      name: "myapp_dev"
    },
    jwt: {
      secret: "dev-secret",
      expiresIn: "7d"
    }
  },
  production: {
    port: process.env.PORT,
    db: {
      host: process.env.DB_HOST,
      port: process.env.DB_PORT,
      name: process.env.DB_NAME
    },
    jwt: {
      secret: process.env.JWT_SECRET,
      expiresIn: "1d"
    }
  }
}

const env = process.env.NODE_ENV || "development"
module.exports = config[env]

const config = require("./config")

app.listen(config.port, () => {
  console.log(`服务器运行在端口 ${config.port}`)
})

const express = require("express")
const helmet = require("helmet")
const cors = require("cors")
const rateLimit = require("express-rate-limit")

const app = express()

// 1. 安全 HTTP 头
app.use(helmet())

// 2. CORS 配置
app.use(cors({
  origin: process.env.ALLOWED_ORIGINS?.split(","),
  credentials: true
}))

// 3. 请求限流
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,  // 15 分钟
  max: 100,                   // 最多 100 个请求
  message: { error: "请求过于频繁，请稍后再试" }
})
app.use("/api", limiter)

// 4. 禁用敏感头
app.disable("x-powered-by")

// 5. 请求体大小限制
app.use(express.json({ limit: "10kb" }))

// 6. 参数污染防护
const hpp = require("hpp")
app.use(hpp())

# 使用 npx 运行（推荐）
npx express-generator myapp

# 或全局安装
npm install -g express-generator
express myapp

express --view=ejs myapp
cd myapp
npm install

myapp/
├── app.js              # 应用入口
├── package.json
├── bin/
│   └── www             # 启动脚本
├── public/             # 静态资源
│   ├── images/
│   ├── javascripts/
│   └── stylesheets/
├── routes/             # 路由
│   ├── index.js
│   └── users.js
└── views/              # 模板
    ├── index.ejs
    └── error.ejs

# 开发环境
npm start

# 或使用 nodemon 热重载
npm install -D nodemon
# 在 package.json 添加 script: "dev": "nodemon ./bin/www"
npm run dev

// 推荐顺序
const express = require("express")
const app = express()

// 1. 安全相关
app.use(helmet())

// 2. 日志
app.use(morgan("dev"))

// 3. 请求体解析
app.use(express.json())
app.use(express.urlencoded({ extended: true }))

// 4. Cookie 和 Session
app.use(cookieParser())
// app.use(session({ ... }))

// 5. 静态文件
app.use(express.static("public"))

// 6. CORS
app.use(cors())

// 7. 限流
app.use("/api", rateLimiter)

// 8. 路由
app.use("/api/users", usersRouter)
app.use("/api/products", productsRouter)

// 9. 404 处理
app.use((req, res) => {
  res.status(404).json({ error: "Not Found" })
})

// 10. 错误处理（最后）
app.use(errorHandler)

// 方案一：async/await + try-catch
app.get("/users/:id", async (req, res, next) => {
  try {
    const user = await User.findById(req.params.id)
    if (!user) return res.status(404).json({ error: "用户不存在" })
    res.json(user)
  } catch (err) {
    next(err)
  }
})

// 方案二：包装函数
const asyncHandler = fn => (req, res, next) =>
  Promise.resolve(fn(req, res, next)).catch(next)

app.get("/users/:id", asyncHandler(async (req, res) => {
  const user = await User.findById(req.params.id)
  if (!user) return res.status(404).json({ error: "用户不存在" })
  res.json(user)
}))

// 成功响应
res.json({
  success: true,
  data: { ... },
  message: "操作成功"
})

// 分页响应
res.json({
  success: true,
  data: [...],
  pagination: {
    page: 1,
    limit: 10,
    total: 100,
    totalPages: 10
  }
})

// 错误响应
res.status(400).json({
  success: false,
  error: {
    code: "VALIDATION_ERROR",
    message: "验证失败",
    details: [...]
  }
})

// 添加 JSON 解析中间件
app.use(express.json())

// 如果是表单数据
app.use(express.urlencoded({ extended: true }))

const cors = require("cors")
app.use(cors())

app.use((req, res, next) => {
  res.header("Access-Control-Allow-Origin", "*")
  res.header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE")
  res.header("Access-Control-Allow-Headers", "Content-Type,Authorization")
  next()
})

// Express 5.0+ 已自动支持
// Express 4.x 需要手动处理
app.get("/async", async (req, res, next) => {
  try {
    const data = await asyncOperation()
    res.json(data)
  } catch (err) {
    next(err)
  }
})

app.set("trust proxy", true)

app.get("/ip", (req, res) => {
  const ip = req.ip
  res.json({ ip })
})

const multer = require("multer")
const upload = multer({ dest: "uploads/" })

app.post("/upload", upload.single("file"), (req, res) => {
  res.json({ file: req.file })
})